home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 9 / PC World Interactive 9 - Temmuz 1998.iso / muzik / RT223.EXE / RTMSPEC.TXT < prev   
Text File  |  1997-09-14  |  5KB  |  202 lines
  1. ------------------------------------------------------------------------------
  2.         Specification of the RTM Format version 1.12
  3.                 by Arnaud Hasenfratz
  4. ------------------------------------------------------------------------------
  5.  
  6. The RTM format use an encapsulated structure : patterns and instruments are
  7. encapsulated in the module and samples are encapsulated in the instruments.
  8.  
  9.  
  10. Global structure :
  11. ------------------
  12.  
  13. struct ObjectHeader :   id="RTMM", name=module_name,
  14. |                       headerSize=sizeof(RTMMHeader)
  15. |
  16. |-------struct RTMMHeader
  17.     |
  18.     Position table
  19.     |
  20.     Track names (if used)
  21.     |
  22.     .
  23.         . (Reserved)
  24.     .
  25. Offset : sizeof(ObjectHeader)+sizeof(RTMMheader)+RTMMHeader.extraDataSize
  26.     |
  27.     struct ObjectHeader :     id="RTND", name=pattern_name,    ]
  28.     |            headerSize=sizeof(RTNDHeader)   ]
  29.     |                                                          ] for each
  30.     |-------struct RTNDHeader                               ] pattern
  31.     |    |                                               ]
  32.     |       Packed pattern data                             ]
  33.     |
  34.     struct ObjectHeader :    id="RTIN", name=instrument_name,]
  35.     |                  headerSize=sizeof(RTINHeader)   ]
  36.     |                                                       ]
  37.     |-------struct RTINHeader                               ]
  38.         |                                               ]
  39.         struct ObjectHeader : id="RTSM",     ]      ] for each
  40.         |           name=sample_name, ]        ] instrument
  41.         |      headerSize=sizeof(RTSMHeader) ] for each ]
  42.         |                                    ] sample   ]
  43.         |-------struct RTSMHeader            ]          ]
  44.             |                            ]          ]
  45.             Delta encoded sample         ]          ]
  46.  
  47.  
  48.  
  49. C declarations :
  50. ----------------
  51.  
  52. struct ObjectHeader
  53. {
  54.     char id[4];         // "RTMM", "RTND", "RTIN" or "RTSM"
  55.     char rc;                // 0x20
  56.     char name[32];          // object name
  57.     char eof;        // '\x1A'
  58.     WORD version;           // version of the format (actual : 0x112)
  59.     WORD headerSize;        // object header size
  60. };
  61.  
  62. struct RTMMHeader        // Real Tracker Music Module
  63. {
  64.     char software[20];      // software used for saving the module
  65.     char composer[32];
  66.     WORD flags;        // song flags
  67.             // bit 0 : linear table, bit 1 : track names present
  68.     BYTE ntrack;            // number of tracks
  69.     BYTE ninstr;        // number of instruments
  70.     WORD nposition;        // number of positions
  71.     WORD npattern;        // number of patterns
  72.     BYTE speed;        // initial speed
  73.     BYTE tempo;        // initial tempo
  74.     char panning[32];    // initial pannings (for S3M compatibility)
  75.     DWORD extraDataSize;    // length of data after the header
  76.     char originalName[32];    // Original name of the module
  77. };
  78.  
  79. struct RTNDHeader        // Real Tracker Pattern
  80. {
  81.     WORD flags;        // Always 1
  82.     BYTE ntrack;
  83.     WORD nrows;
  84.     DWORD datasize;
  85. };
  86.  
  87. struct EnvelopePoint
  88. {
  89.     long x;
  90.     long y;
  91. };
  92.  
  93. struct Envelope
  94. {
  95.     BYTE npoint;
  96.     EnvelopePoint point[12];
  97.     BYTE sustain;
  98.     BYTE loopstart;
  99.     BYTE loopend;
  100.     WORD flags;// bit 0 : enable envelope, bit 1 : sustain, bit 2 : loop
  101. };
  102.  
  103. struct RTINHeader     // Real Tracker Instrument
  104. {
  105.     BYTE nsample;
  106.     WORD flags;        // bit 0 : default panning enabled, bit 1 : mute samples
  107.     BYTE table[120];    // sample number for each note
  108.     Envelope volumeEnv;
  109.     Envelope panningEnv;
  110.     char vibflg;               // vibrato type
  111.     char vibsweep;             // vibrato sweep
  112.     char vibdepth;             // vibrato depth
  113.     char vibrate;              // vibrato rate
  114.     WORD volfade;
  115.     BYTE midiPort;
  116.     BYTE midiChannel;
  117.     BYTE midiProgram;
  118.     BYTE midiEnable;
  119.     char midiTranspose;
  120.     BYTE midiBenderRange;
  121.     BYTE midiBaseVolume;
  122.     char midiUseVelocity;
  123. };
  124.  
  125. struct RTSMHeader           // Real Tracker Sample
  126. {
  127.     WORD flags;    // bit 1 : 16 bits, bit 2 : delta encoded (always)
  128.     BYTE basevolume;
  129.     BYTE defaultvolume;
  130.     DWORD length;
  131.     BYTE loop;    // =0:no loop, =1:forward loop, =2:bi-directional loop
  132.     BYTE reserved[3];
  133.     DWORD loopbegin;
  134.     DWORD loopend;
  135.     DWORD basefreq;
  136.     BYTE basenote;
  137.     char panning;        // Panning from -64 to 64
  138. };
  139.  
  140.  
  141. How to read an object header :
  142. ------------------------------
  143.  
  144. Headers must be read this way to ensure that new versions of the format are
  145. compatibles with old loaders.
  146.  
  147. - if header_size=sizeof(header)
  148.     - read header into the structure
  149.  
  150. - if header_size<sizeof(header)
  151.     - fill the structure with zeros
  152.     - read header_size bytes of the header into the structure
  153.  
  154. - if header_size>sizeof(header)
  155.     - read the header into the structure
  156.     - skip header_size-sizeof(header) bytes in the file
  157.  
  158.  
  159. Position table :
  160. ----------------
  161.  
  162. One WORD per position.
  163.  
  164.  
  165. Track names :
  166. -------------
  167.  
  168. 16 chars per track.
  169.  
  170.  
  171. How to read patterns :
  172. ----------------------
  173.  
  174. The format use a simple packing system. To unpack, read the packed data as
  175. follow :
  176.  
  177. begin:
  178. - read byte
  179. - if byte=0, go to next row
  180.   else :
  181.         - if bit 0 set, read the track number (first track is 0) and go to this
  182.         track
  183.     - if bit 1 set, read note (0=C-0 1=C#0 etc..., 254=key off)
  184.     - if bit 2 set, read instrument number
  185.     - if bit 3 set, read left command
  186.     - if bit 4 set, read left parameter
  187.     - if bit 5 set, read right command
  188.     - if bit 6 set, read right parameter
  189. - go to next track
  190. - goto begin
  191.  
  192.  
  193. How to read samples
  194. -------------------
  195.  
  196. - current=0
  197. - for each sample :
  198.         - current=current+encoded_sample
  199.         - sample=current
  200.  
  201. (current,sample and encoded_sample are signed, 8 or 16 bits)
  202.